home *** CD-ROM | disk | FTP | other *** search
/ Aminet 44 / Aminet 44 (2001)(GTI - Schatztruhe)[!][Aug 2001].iso / Aminet / dev / moni / systemviewer.lha / SysTasks.c < prev    next >
C/C++ Source or Header  |  2001-04-25  |  35KB  |  1,395 lines
  1. /****h* SystemViewer/SysTasks.c [1.1] ********************************
  2. *
  3. * NAME
  4. *    SysTasks.c
  5. *
  6. * DESCRIPTION
  7. *    Display a list of all tasks & processes currently loaded into
  8. *    the OS.  Allow the user to signal, break, & view almost all
  9. *    important parameters of the task or process.
  10. *
  11. * FUNCTIONAL INTERFACE:
  12. *
  13. *    PUBLIC void RemovePortSafely( struct MsgPort *port );
  14. *
  15. *    PUBLIC int HandleTaskListView( void );
  16. *
  17. *  GUI Designed by : Jim Steichen
  18. **********************************************************************
  19. *
  20. */
  21.  
  22. #include <stdio.h>
  23. #include <string.h>
  24.  
  25. #include <exec/execbase.h>
  26. #include <exec/types.h>
  27.  
  28. #include <dos/dosextens.h>
  29.  
  30. #include <AmigaDOSErrs.h>
  31.  
  32. #include <intuition/intuitionbase.h>
  33. #include <intuition/intuition.h>
  34. #include <intuition/classes.h>
  35. #include <intuition/classusr.h>
  36. #include <intuition/gadgetclass.h>
  37.  
  38. #include <libraries/gadtools.h>
  39.  
  40. #include <graphics/displayinfo.h>
  41. #include <graphics/gfxbase.h>
  42.  
  43. #include <clib/exec_protos.h>
  44. #include <clib/intuition_protos.h>
  45. #include <clib/gadtools_protos.h>
  46. #include <clib/graphics_protos.h>
  47. #include <clib/utility_protos.h>
  48. #include <clib/diskfont_protos.h>
  49.  
  50. #include "CPGM:GlobalObjects/CommonFuncs.h"
  51.  
  52. #include "SysLists.h"
  53.  
  54. #define XPOS       6
  55. #define MAX_HEIGHT 370
  56.  
  57. PRIVATE void WriteTask( void *ptr );
  58.  
  59. PRIVATE char ver[] = "\0$VER: SysTasks 1.1 (25-Apr-2001) by J.T. Steichen\0";
  60.  
  61. PRIVATE struct Window *IWnd = NULL;
  62.  
  63. PRIVATE UWORD ILeft   = 0;
  64. PRIVATE UWORD ITop    = 32;
  65. PRIVATE UWORD IWidth  = 640;
  66. PRIVATE UWORD IHeight = MAX_HEIGHT;
  67.  
  68. PRIVATE UBYTE *IWTitle = "System Tasks & Processes Full Info:";
  69.  
  70. PRIVATE struct Gadget *TaskGadgets[ T_CNT ];
  71.  
  72. PRIVATE UBYTE *WTitle = "System Tasks & Processes Info:";
  73.  
  74. // defined in SysLists.h:  PRIVATE struct Window *Wnd = NULL;
  75.  
  76. PRIVATE UWORD StrYPos[32] = { 0, };
  77.  
  78. // ---------------------------------------------------------------
  79.  
  80. PRIVATE UBYTE *ttl = "Address    Pri  Stack Signals  State     Type    Name";
  81.  
  82. #define MAXNODE    100
  83. #define NODELENGTH 80
  84.  
  85. PRIVATE struct List TskLVList;
  86.  
  87. PRIVATE struct Node TskLVNodes[ MAXNODE ]            = { NULL, };
  88. PRIVATE UBYTE       NodeStrs[ MAXNODE * NODELENGTH ] = "";
  89.  
  90. PRIVATE struct ListViewMem lvm = { 0, };
  91.     
  92. // ---------------------------------------------------------------
  93.  
  94. PRIVATE UWORD TaskGTypes[] = {
  95.  
  96.    LISTVIEW_KIND, BUTTON_KIND,   BUTTON_KIND,
  97.    BUTTON_KIND,   BUTTON_KIND,   BUTTON_KIND,
  98.    BUTTON_KIND,   BUTTON_KIND,   BUTTON_KIND, TEXT_KIND
  99. };
  100.  
  101. PRIVATE int TLVClicked(      int itemnum );
  102. PRIVATE int UpdateClicked(   int dummy   );
  103. PRIVATE int RemoveClicked(   int dummy   );
  104. PRIVATE int PriorityClicked( int dummy   );
  105. PRIVATE int CancelClicked(   int dummy   );
  106. PRIVATE int FreezeClicked(   int dummy   );
  107. PRIVATE int MoreClicked(     int dummy   );
  108. PRIVATE int SignalClicked(   int dummy   );
  109. PRIVATE int BreakClicked(    int dummy   );
  110.  
  111. /* Since this is an array, the gadgets are in numerical order 
  112. ** (by GadgetID number).
  113. */
  114.  
  115. PRIVATE struct NewGadget TaskNGad[] = {
  116.  
  117.      2,   3, 627, 200,                 NULL, NULL, TaskLV, 
  118.    0,            NULL, (APTR) TLVClicked,
  119.    
  120.      4, 205,  71,  17, (UBYTE *) "_Update",  NULL, TUpdate, 
  121.    PLACETEXT_IN, NULL, (APTR) UpdateClicked,
  122.    
  123.     82, 205,  71,  17, (UBYTE *) "_More",    NULL, TMore, 
  124.    PLACETEXT_IN, NULL, (APTR) MoreClicked,
  125.    
  126.    554, 205,  72,  17, (UBYTE *) "_Cancel",  NULL, TCancel, 
  127.    PLACETEXT_IN, NULL, (APTR) CancelClicked,
  128.    
  129.    474, 205,  72,  17, (UBYTE *) "Freeze",   NULL, TFreeze, 
  130.    PLACETEXT_IN, NULL, (APTR) FreezeClicked,
  131.    
  132.    317, 205,  72,  17, (UBYTE *) "Remove",   NULL, TRemove, 
  133.    PLACETEXT_IN, NULL, (APTR) RemoveClicked,
  134.    
  135.    160, 205,  72,  17, (UBYTE *) "Signal",   NULL, TSignal, 
  136.    PLACETEXT_IN, NULL, (APTR) SignalClicked,
  137.    
  138.    238, 205,  72,  17, (UBYTE *) "_Break",   NULL, TBreak, 
  139.    PLACETEXT_IN, NULL, (APTR) BreakClicked,
  140.       
  141.    396, 205,  72,  17, (UBYTE *) "Priority", NULL, TPriority, 
  142.    PLACETEXT_IN, NULL, (APTR) PriorityClicked,
  143.    
  144.      5, 228, 620,  17,                 NULL, NULL, TSelection,
  145.               0, NULL, NULL
  146. };
  147.  
  148. PRIVATE ULONG TaskGTags[] = {
  149.  
  150.    GTLV_ShowSelected, NULL, (LAYOUTA_Spacing), 2, (TAG_DONE),
  151.  
  152.    (GT_Underscore), '_', (TAG_DONE),
  153.    (GT_Underscore), '_', (GA_Disabled), TRUE, (TAG_DONE),
  154.    (GT_Underscore), '_', (TAG_DONE),
  155.  
  156.    (GA_Disabled),  TRUE, (TAG_DONE),
  157.    (GA_Disabled),  TRUE, (TAG_DONE),
  158.    (GA_Disabled),  TRUE, (TAG_DONE),
  159.  
  160.    (GT_Underscore), '_', (GA_Disabled), TRUE, (TAG_DONE),
  161.  
  162.    (GA_Disabled),  TRUE, (TAG_DONE),
  163.  
  164.    (GTTX_Border),  TRUE, TAG_DONE
  165. };
  166.  
  167. // --------------------------------------------------------------------
  168.  
  169. PRIVATE void WriteText( char *string, int xpos, int ypos, int color ) 
  170. {
  171.    struct RastPort  *rp = IWnd->RPort;
  172.    struct IntuiText  outtxt;
  173.  
  174.    outtxt.FrontPen  = color;
  175.    outtxt.BackPen   = 0;
  176.    outtxt.DrawMode  = JAM1;
  177.    outtxt.LeftEdge  = 0;
  178.    outtxt.TopEdge   = 0;
  179.    outtxt.ITextFont = Font;
  180.    outtxt.NextText  = NULL;
  181.    outtxt.IText     = (UBYTE *) string;
  182.  
  183.    PrintIText( rp, &outtxt, xpos, ypos );
  184.  
  185.    return;
  186. }
  187.  
  188.  
  189. PRIVATE BOOL CheckWindow( struct Window *findwin )
  190. {
  191.   struct Window *win;
  192.   struct Screen *scr;
  193.   ULONG          lock = 0L;
  194.   BOOL           ret  = FALSE;
  195.  
  196.   lock = LockIBase( NULL );
  197.  
  198.   scr = IntuitionBase->FirstScreen;
  199.   
  200.   while ((scr != NULL) && (ret == FALSE))
  201.      {
  202.      win = scr->FirstWindow;
  203.      
  204.      while (win != NULL)
  205.         {
  206.         if (win == findwin)
  207.            {
  208.            ret = TRUE;
  209.            break;
  210.            }
  211.  
  212.         win = win->NextWindow;
  213.         }
  214.  
  215.      scr = scr->NextScreen;
  216.      }
  217.  
  218.   UnlockIBase( lock );
  219.  
  220.   return( ret );
  221. }
  222.  
  223. PRIVATE void CloseIWindow( void )
  224. {
  225.    if (IWnd != NULL) 
  226.       {
  227.       CloseWindow( IWnd );
  228.       IWnd = NULL;
  229.       }
  230.  
  231.    return;
  232. }
  233.  
  234. PRIVATE int ICloseWindow( void )
  235. {
  236.    CloseIWindow();
  237.    return( (int) FALSE );
  238. }
  239.  
  240. PRIVATE BOOL CheckBit( int flags, int bit )
  241. {
  242.    if ((flags & bit) == bit)
  243.       return( TRUE );
  244.    else
  245.       return( FALSE );
  246. }
  247.  
  248. PRIVATE void DisplayStructure( void *ptr, int struct_type )
  249. {
  250.    switch (struct_type)
  251.       {
  252.       case 2: // Task structure:
  253.          WriteTask( ptr );
  254.          break;
  255.  
  256.       case 3: // Process structure:
  257.          WriteTask( ptr );
  258.          break;
  259.       }
  260.  
  261.    return;
  262. }
  263.  
  264. PRIVATE int OpenIWindow( int numlines )
  265. {
  266.    UWORD wleft = ILeft, wtop = ITop, ww, wh;
  267.    int   i;
  268.    
  269.    ComputeFont( Scr, Font, &CFont, IWidth, IHeight );
  270.  
  271.    IHeight = (numlines + 1) * (CFont.FontY + 3) + 2;
  272.  
  273.    if (IHeight > MAX_HEIGHT)
  274.       IHeight = MAX_HEIGHT;
  275.  
  276.    for (i = 0; i < 32; i++)
  277.       StrYPos[i] = 16 + i * (CFont.FontY + 3);
  278.          
  279.    ww = ComputeX( CFont.FontX, IWidth  );
  280.    wh = ComputeY( CFont.FontY, IHeight );
  281.  
  282.    if ((wleft + ww + CFont.OffX + Scr->WBorRight) > Scr->Width) 
  283.       wleft = Scr->Width - ww;
  284.  
  285.    if ((wtop + wh + CFont.OffY + Scr->WBorBottom) > Scr->Height) 
  286.       wtop = Scr->Height - wh;
  287.  
  288.    if ( !(IWnd = OpenWindowTags( NULL,
  289.  
  290.                    WA_Left,        wleft,
  291.                    WA_Top,         wtop,
  292.                    WA_Width,       ww + CFont.OffX + Scr->WBorRight,
  293.                    WA_Height,      wh + CFont.OffY + Scr->WBorBottom,
  294.  
  295.                    WA_IDCMP,       BUTTONIDCMP | IDCMP_GADGETUP
  296.                      | IDCMP_REFRESHWINDOW | IDCMP_CLOSEWINDOW,
  297.  
  298.                    WA_Flags,       WFLG_SMART_REFRESH | WFLG_CLOSEGADGET 
  299.                      | WFLG_ACTIVATE | WFLG_RMBTRAP,
  300.  
  301.                    WA_Gadgets,     NULL,
  302.                    WA_Title,       IWTitle,
  303.                    WA_ScreenTitle, ScrTitle,
  304.                    TAG_DONE ))
  305.       )
  306.       return( -4 );
  307.  
  308.    return( 0 );
  309. }
  310.  
  311. PRIVATE int HandleInfoIDCMP( void )
  312. {
  313.    struct IntuiMessage    *m;
  314.    BOOL            running = TRUE;
  315.  
  316.    while (running == TRUE)
  317.       {
  318.       if ((m = (struct IntuiMessag *) GetMsg( IWnd->UserPort )) == NULL)
  319.          {
  320.          (void) Wait( 1L << IWnd->UserPort->mp_SigBit );
  321.          continue;
  322.          }
  323.  
  324.       CopyMem( (char *) m, (char *) &IMsg, 
  325.                (long) sizeof( struct IntuiMessage )
  326.              );
  327.  
  328.       ReplyMsg( (struct Message *) m );
  329.  
  330.       switch (IMsg.Class) 
  331.          {
  332.         case IDCMP_CLOSEWINDOW:
  333.            running = ICloseWindow();
  334.             break;
  335.          }
  336.       }
  337.  
  338.    return( running );
  339. }
  340.  
  341. PUBLIC int HandleWindowInfo( void *structptr, int whichdisplay )
  342. {
  343.    int rval = 0;
  344.    
  345.    switch (whichdisplay)
  346.       {
  347.       case 2: // Task data:
  348.          rval = OpenIWindow( 13 );
  349.          break;
  350.  
  351.       case 3: // Process data:
  352.          rval = OpenIWindow( 28 );
  353.          break;
  354.       }
  355.    
  356.    if (rval < 0)
  357.       {
  358.       UserInfo( "Couldn't open Information Window!","Allocation Problem:");
  359.  
  360.       return( -1 );
  361.       }
  362.  
  363.    DisplayStructure( structptr, whichdisplay );
  364.       
  365.    (void) HandleInfoIDCMP();
  366.  
  367.    return( 0 );
  368. }
  369.  
  370. PRIVATE char ts[10], *taskstate = &ts[0];
  371. PRIVATE BOOL DispTaskFlag = TRUE;
  372.  
  373. PRIVATE char *GetTaskState( struct Task *t )
  374. {
  375.    if (t == NULL)
  376.       return( "INVALID" );
  377.  
  378.    switch (t->tc_State)
  379.       {
  380.       case TS_INVALID:
  381.          strcpy( taskstate, "INVALID" );  // Stack won't be right.
  382.          DispTaskFlag = FALSE;
  383.          break;
  384.          
  385.       case TS_ADDED:
  386.          strcpy( taskstate, "ADDED" );
  387.          DispTaskFlag = TRUE;
  388.          break;
  389.          
  390.       case TS_RUN:
  391.          strcpy( taskstate, "RUNNING" );
  392.          DispTaskFlag = TRUE;
  393.          break;
  394.          
  395.       case TS_READY:
  396.          strcpy( taskstate, "READY" );
  397.          DispTaskFlag = TRUE;
  398.          break;
  399.          
  400.       case TS_WAIT:
  401.          strcpy( taskstate, "WAITING" );
  402.          DispTaskFlag = TRUE;
  403.          break;
  404.          
  405.       case TS_EXCEPT:
  406.          strcpy( taskstate, "EXCEPTION" );
  407.          DispTaskFlag = TRUE;
  408.          break;
  409.          
  410.       case TS_REMOVED:
  411.          strcpy( taskstate, "REMOVED" );
  412.          DispTaskFlag = TRUE;
  413.          break;
  414.       }
  415.  
  416.    return( taskstate );
  417. }
  418.  
  419. PRIVATE void SetTaskFlags( struct Task *t, char *str )
  420. {
  421.    *str = '\0';
  422.  
  423.    if (CheckBit( t->tc_Flags, TF_PROCTIME ) == TRUE)
  424.       strcpy( str, "TF_PROCTIME " );
  425.    
  426.    if (CheckBit( t->tc_Flags, TF_ETASK ) == TRUE)
  427.       strcat( str, "TF_ETASK " );
  428.  
  429.    if (CheckBit( t->tc_Flags, TF_STACKCHK ) == TRUE)
  430.       strcat( str, "TF_STACKCHK " );
  431.  
  432.    if (CheckBit( t->tc_Flags, TF_EXCEPT ) == TRUE)
  433.       strcat( str, "TF_EXCEPT " );
  434.  
  435.    if (CheckBit( t->tc_Flags, TF_SWITCH ) == TRUE)
  436.       strcat( str, "TF_SWITCH " );
  437.  
  438.    if (CheckBit( t->tc_Flags, TF_LAUNCH ) == TRUE)
  439.       strcat( str, "TF_LAUNCH" );
  440.  
  441.    return;
  442. }
  443.  
  444. PRIVATE char typ[10], *pgmtype = &typ[0];
  445.  
  446. PRIVATE char *GetTask_Process( UBYTE type )
  447. {
  448.    if (type == NT_TASK)
  449.       strcpy( pgmtype, "TASK" );
  450.    else if (type == NT_PROCESS)
  451.       strcpy( pgmtype, "PROCESS" );
  452.    else   
  453.       strcpy( pgmtype, "TASK" );
  454.  
  455.    return( pgmtype );
  456. }
  457.  
  458. #define B2APTR( bptr ) ((bptr) << 2)
  459.  
  460. #define XPOS 6
  461.  
  462. PRIVATE void WriteTask( void *ptr )
  463. {
  464.    IMPORT UWORD StrYPos[];
  465.    
  466.    struct Task    *task    = (struct Task *) ptr;
  467.    struct Process *process = NULL;
  468.  
  469.    char t[82], *title = &t[0];
  470.    char s[82], *str   = &s[0];
  471.  
  472.    int  size = 0;
  473.    
  474.    if (task == NULL)
  475.       return; 
  476.  
  477.    sprintf( title, "%10.10s: (%08LX) -> %-32.32s", 
  478.             GetTask_Process( task->tc_Node.ln_Type ),
  479.             task, task->tc_Node.ln_Name
  480.           );
  481.  
  482.    DisplayTitle( Wnd, title );
  483.  
  484.    // Common (to Task & Process) data to display:
  485.    if ((task->tc_Node.ln_Type == NT_TASK) 
  486.        || (task->tc_Node.ln_Type == NT_PROCESS))
  487.       {
  488.       sprintf( str, "STATE: %s Priority: %4d", 
  489.                GetTaskState( task ),
  490.                task->tc_Node.ln_Pri 
  491.              );
  492.  
  493.       WriteText( str, XPOS, StrYPos[0], 2 );
  494.  
  495.       sprintf( str, "SigAlloc: %08LX SigWait : %08LX SigRecvd : %08LX SigExcept: %08LX", 
  496.                task->tc_SigAlloc, task->tc_SigWait, 
  497.                task->tc_SigRecvd, task->tc_SigExcept
  498.              );
  499.  
  500.       WriteText( str, XPOS, StrYPos[1], 1 );
  501.  
  502.       sprintf( str, "TrapData: %08LX TrapCode: %08LX TrapAlloc: %08LX TrapAble : %08LX",
  503.                task->tc_TrapData, task->tc_TrapCode, 
  504.                task->tc_TrapAlloc, task->tc_TrapAble
  505.              );
  506.  
  507.       WriteText( str, XPOS, StrYPos[2], 1 );
  508.  
  509.       sprintf( str, "Switch(): %08LX Launch(): %08LX UserData : %08LX", 
  510.                task->tc_Switch, task->tc_Launch, 
  511.                task->tc_UserData
  512.              );
  513.  
  514.       WriteText( str, XPOS, StrYPos[3], 2 );
  515.  
  516.       sprintf( str, "ExceptData: %08LX ExceptCode: %08LX", 
  517.                task->tc_ExceptData, task->tc_ExceptCode
  518.              );
  519.  
  520.       WriteText( str, XPOS, StrYPos[5], 1 );
  521.  
  522.       size = (int) task->tc_SPUpper - (int) task->tc_SPLower;
  523.  
  524.       sprintf( str, "SPReg     : %08LX SPUpper   : %08LX SPLower: %08LX size: %d",
  525.                task->tc_SPReg, task->tc_SPUpper, 
  526.                task->tc_SPLower, size
  527.              );
  528.  
  529.       WriteText( str, XPOS, StrYPos[6], 2 );
  530.  
  531.       sprintf( str, "IDNestCnt: %-08d TDNestCnt: %3d",
  532.                task->tc_IDNestCnt, task->tc_TDNestCnt
  533.              );
  534.  
  535.       WriteText( str, XPOS, StrYPos[8], 1 );
  536.  
  537.       sprintf( str, "MemEntry : %08LX", task->tc_MemEntry.lh_Head );
  538.  
  539.       WriteText( str, XPOS, StrYPos[9], 1 );
  540.  
  541.       WriteText( "Flags:", XPOS, StrYPos[10], 3 );
  542.  
  543.       SetTaskFlags( task, str );
  544.  
  545.       WriteText( str, XPOS, StrYPos[11], 1 );
  546.  
  547.       if (task->tc_Node.ln_Type == NT_TASK) 
  548.          WriteText( "Press Close Gadget when you're done!", 
  549.                     150, StrYPos[12], 2 
  550.                   ); 
  551.       }
  552.  
  553.    // Process additions to display:
  554.    if (task->tc_Node.ln_Type == NT_PROCESS)
  555.       {
  556.       char   pn[256], *path = &pn[0];
  557.       UBYTE *ttl = NULL;
  558.             
  559.       process = (struct Process *) ptr;
  560.  
  561.       WriteText( "Process Structure:", XPOS, StrYPos[12], 3 );  
  562.  
  563.       if ((struct Window *) process->pr_WindowPtr != NULL)
  564.          ttl = ((struct Window *) process->pr_WindowPtr)->Title;
  565.       else
  566.          ttl = "*NO TITLE!*";
  567.  
  568.       sprintf( str, "WindowPtr  : %08LX Title: %-40.40s", 
  569.                process->pr_WindowPtr, 
  570.                (strlen( ttl ) > 0) ? ttl : (UBYTE *) "*NO TITLE!*"
  571.              );
  572.  
  573.       WriteText( str, XPOS, StrYPos[13], 2 );
  574.  
  575.       if (process->pr_CurrentDir != NULL)
  576.          (void) NameFromLock( process->pr_CurrentDir, path, 255 );
  577.           
  578.       sprintf( str, "CurrentDir : %08LX Path : %-40.40s", 
  579.                B2APTR( process->pr_CurrentDir ),
  580.                (path == NULL) ? "*NO PATH*" : path
  581.              );
  582.  
  583.       WriteText( str, XPOS, StrYPos[14], 2 );
  584.  
  585.       sprintf( str, "MsgPort    : %08LX SegList       : %08LX", 
  586.                process->pr_MsgPort, B2APTR( process->pr_SegList )
  587.              );
  588.  
  589.       WriteText( str, XPOS, StrYPos[15], 1 );
  590.  
  591.       sprintf( str, "StackBase  : %08LX StackSize     : %d", 
  592.                B2APTR( process->pr_StackBase ), process->pr_StackSize
  593.              );
  594.  
  595.       WriteText( str, XPOS, StrYPos[16], 1 );
  596.  
  597.       sprintf( str, "CIS        : %08LX COS           : %08LX", 
  598.                B2APTR( process->pr_CIS ), B2APTR( process->pr_COS )
  599.              );
  600.  
  601.       WriteText( str, XPOS, StrYPos[17], 1 );
  602.  
  603.       sprintf( str, "ConsoleTask: %08LX FileSystemTask: %08LX", 
  604.                process->pr_ConsoleTask, 
  605.                process->pr_FileSystemTask
  606.              );
  607.  
  608.       WriteText( str, XPOS, StrYPos[18], 1 );
  609.  
  610.       sprintf( str, "PktWait    : %08LX ReturnAddr    : %08LX", 
  611.                process->pr_PktWait, 
  612.                process->pr_ReturnAddr
  613.              );
  614.  
  615.       WriteText( str, XPOS, StrYPos[19], 1 );
  616.  
  617.       sprintf( str, "Arguments -> %-60.60s", 
  618.                (process->pr_Arguments == NULL) ? (UBYTE *) "*NO ARGS!*" 
  619.                                                : process->pr_Arguments
  620.              );
  621.  
  622.       WriteText( str, XPOS, StrYPos[20], 2 );
  623.  
  624.       sprintf( str, "GlobVec    : %08LX CLI           : %08LX", 
  625.                process->pr_GlobVec, 
  626.                B2APTR( process->pr_CLI )
  627.              );
  628.  
  629.       WriteText( str, XPOS, StrYPos[21], 1 );
  630.  
  631.       // CLI additional information: 
  632.  
  633.       if (process->pr_CLI != NULL)
  634.          {
  635.          struct CommandLineInterface *cli = NULL;
  636.          BOOL                         iflag = FALSE, bflag = FALSE;
  637.  
  638.          cli = (struct CommandLineInterface *) (process->pr_CLI << 2);
  639.  
  640.          WriteText( "CommandLineInterface structure:", 
  641.                     XPOS, StrYPos[22], 3
  642.                   );
  643.  
  644.          sprintf( str, "CommandDir   : %08LX", 
  645.                   B2APTR( cli->cli_CommandDir )
  646.                 );
  647.  
  648.          WriteText( str, XPOS, StrYPos[23], 1 );
  649.  
  650.          sprintf( str, "StandardInput: %08LX StandardOutput: %08LX", 
  651.                   B2APTR( cli->cli_StandardInput ),
  652.                   B2APTR( cli->cli_StandardOutput )
  653.                 );
  654.  
  655.          WriteText( str, XPOS, StrYPos[24], 1 );
  656.  
  657.          sprintf( str, "CurrentInput : %08LX CurrentOutput : %08LX", 
  658.                   B2APTR( cli->cli_CurrentInput  ),
  659.                   B2APTR( cli->cli_CurrentOutput )
  660.                 );
  661.  
  662.          WriteText( str, XPOS, StrYPos[25], 1 );
  663.  
  664.          if (cli->cli_Interactive != FALSE)
  665.             iflag = TRUE;
  666.             
  667.          if (cli->cli_Background != FALSE)
  668.             bflag = TRUE;
  669.             
  670.          sprintf( str, "Module       : %08LX %s %s", 
  671.                   B2APTR( cli->cli_Module ),
  672.                   (bflag == TRUE) ? "BACKGROUND" : "",
  673.                   (iflag == TRUE) ? "& INTERACTIVE" : ""
  674.                 );
  675.  
  676.          WriteText( str, XPOS, StrYPos[26], 1 );
  677.          }
  678.  
  679.       WriteText( "Press Close Gadget when you're done!", 
  680.                  150, StrYPos[27], 2 
  681.                ); 
  682.       }
  683.  
  684.    return;
  685. }
  686.  
  687. PRIVATE int MakeTaskList( void )
  688. {
  689.    IMPORT struct ExecBase *SysBase;
  690.    
  691.    struct Task *readytasks = NULL;
  692.    struct Task *waitgtasks = NULL;
  693.    struct Task *crnttask   = NULL;
  694.    struct Node *ptr        = NULL;
  695.  
  696.    char        *tskstate = NULL;
  697.    int          numitems = 0, i = 1;
  698.    int          up, down;
  699.         
  700.  
  701.    Forbid();
  702.  
  703.      crnttask = SysBase->ThisTask;
  704.  
  705.      up   = (int) crnttask->tc_SPUpper;
  706.      down = (int) crnttask->tc_SPLower;
  707.  
  708.      sprintf( &NodeStrs[ i++ * NODELENGTH ], 
  709.               "%08LX+ %4d %6u %08LX %-9.9s %-7.7s %-30.30s",
  710.               crnttask, 
  711.               crnttask->tc_Node.ln_Pri, 
  712.               up - down,
  713.               crnttask->tc_SigAlloc,
  714.               GetTaskState( crnttask ),
  715.               GetTask_Process( crnttask->tc_Node.ln_Type ),
  716.               crnttask->tc_Node.ln_Name
  717.             );
  718.      
  719.      numitems++;
  720.  
  721.      ptr        = SysBase->TaskReady.lh_Head;
  722.      readytasks = (struct Task *) ptr;
  723.  
  724.      while (ptr != NULL)
  725.         {
  726.         up   = (int) readytasks->tc_SPUpper;
  727.         down = (int) readytasks->tc_SPLower;
  728.  
  729.         tskstate = GetTaskState( readytasks );
  730.  
  731.         if (DispTaskFlag == TRUE)
  732.            sprintf( &NodeStrs[ i++ * NODELENGTH ], 
  733.                     "%08LX  %4d %6u %08LX %-9.9s %-7.7s %-30.30s",
  734.                     readytasks, 
  735.                     readytasks->tc_Node.ln_Pri, 
  736.                     up - down,
  737.                     readytasks->tc_SigAlloc,
  738.                     tskstate,
  739.                     GetTask_Process( readytasks->tc_Node.ln_Type ),
  740.                     readytasks->tc_Node.ln_Name
  741.                   );
  742.              
  743.         // point to next node in list:
  744.         ptr        = ptr->ln_Succ;
  745.         readytasks = (struct Task *) ptr;
  746.         numitems++;
  747.         }
  748.  
  749.      ptr        = SysBase->TaskWait.lh_Head;
  750.      waitgtasks = (struct Task *) ptr;
  751.  
  752.      while (ptr != NULL)
  753.         {
  754.         up   = (int) waitgtasks->tc_SPUpper;
  755.         down = (int) waitgtasks->tc_SPLower;
  756.  
  757.         tskstate = GetTaskState( waitgtasks );
  758.  
  759.         if (DispTaskFlag == TRUE)
  760.            sprintf( &NodeStrs[ i++ * NODELENGTH ], 
  761.                     "%08LX  %4d %6u %08LX %-9.9s %-7.7s %-30.30s",
  762.                     waitgtasks, 
  763.                     waitgtasks->tc_Node.ln_Pri, 
  764.                     up - down,
  765.                     waitgtasks->tc_SigAlloc,
  766.                     GetTaskState( waitgtasks ),
  767.                     GetTask_Process( waitgtasks->tc_Node.ln_Type ),
  768.                     waitgtasks->tc_Node.ln_Name
  769.                   );
  770.              
  771.         // point to next node in list:
  772.         ptr        = ptr->ln_Succ;
  773.         waitgtasks = (struct Task *) ptr;
  774.  
  775.         numitems++;
  776.         }
  777.  
  778.    Permit();
  779.  
  780.    return( numitems );
  781. }
  782.  
  783. PRIVATE ULONG TaskAddress = 0L;
  784.  
  785. PRIVATE int TLVClicked( int itemnum )
  786. {
  787.    ULONG addr = 0L;
  788.    
  789. //#  ifdef DEBUG
  790. //   fprintf( stderr, "%-80.80s\n", TskLVNodes[ itemnum ].ln_Name );
  791. //#  endif
  792.  
  793.    if (itemnum == 0)   
  794.       {
  795.       GT_SetGadgetAttrs( TaskGadgets[ TMore ], Wnd, NULL,
  796.                          GA_Disabled, TRUE, TAG_DONE 
  797.                        );
  798.  
  799.       GT_SetGadgetAttrs( TaskGadgets[ TFreeze ], Wnd, NULL,
  800.                          GA_Disabled, TRUE, TAG_DONE 
  801.                        );
  802.  
  803.       GT_SetGadgetAttrs( TaskGadgets[ TRemove ], Wnd, NULL,
  804.                          GA_Disabled, TRUE, TAG_DONE 
  805.                        );
  806.  
  807.       GT_SetGadgetAttrs( TaskGadgets[ TSignal ], Wnd, NULL,
  808.                          GA_Disabled, TRUE, TAG_DONE 
  809.                        );
  810.  
  811.       GT_SetGadgetAttrs( TaskGadgets[ TBreak ], Wnd, NULL,
  812.                          GA_Disabled, TRUE, TAG_DONE 
  813.                        );
  814.  
  815.       GT_SetGadgetAttrs( TaskGadgets[ TPriority ], Wnd, NULL,
  816.                          GA_Disabled, TRUE, TAG_DONE 
  817.                        );
  818.  
  819.       GT_SetGadgetAttrs( TaskGadgets[ TSelection ], Wnd, NULL,
  820.                          GTTX_Text, NULL,
  821.                          TAG_DONE
  822.                        );
  823.  
  824.       return( (int) TRUE );
  825.       }
  826.    else
  827.       {
  828.       GT_SetGadgetAttrs( TaskGadgets[ TMore ], Wnd, NULL,
  829.                          GA_Disabled, FALSE, TAG_DONE 
  830.                        );
  831.  
  832.       GT_SetGadgetAttrs( TaskGadgets[ TFreeze ], Wnd, NULL,
  833.                          GA_Disabled, FALSE, TAG_DONE 
  834.                        );
  835.  
  836.       GT_SetGadgetAttrs( TaskGadgets[ TRemove ], Wnd, NULL,
  837.                          GA_Disabled, FALSE, TAG_DONE 
  838.                        );
  839.  
  840.       GT_SetGadgetAttrs( TaskGadgets[ TSignal ], Wnd, NULL,
  841.                          GA_Disabled, FALSE, TAG_DONE 
  842.                        );
  843.  
  844.       GT_SetGadgetAttrs( TaskGadgets[ TBreak ], Wnd, NULL,
  845.                          GA_Disabled, FALSE, TAG_DONE 
  846.                        );
  847.  
  848.       GT_SetGadgetAttrs( TaskGadgets[ TPriority ], Wnd, NULL,
  849.                          GA_Disabled, FALSE, TAG_DONE 
  850.                        );
  851.  
  852.       GT_SetGadgetAttrs( TaskGadgets[ TSelection ], Wnd, NULL,
  853.                          GTTX_Text, TskLVNodes[ itemnum ].ln_Name, 
  854.                          TAG_DONE
  855.                        );
  856.  
  857.       // Now get address from the item:
  858.       (void) stch_l( TskLVNodes[ itemnum ].ln_Name, (long *) &addr );
  859.  
  860.       TaskAddress = addr;
  861.       }
  862.  
  863.    return( (int) TRUE );
  864. }
  865.  
  866. PRIVATE int UpdateClicked( int dummy )
  867. {
  868.    int i;
  869.    
  870.    GT_SetGadgetAttrs( TaskGadgets[ TSelection ], Wnd, NULL,
  871.                       GTTX_Text, NULL,
  872.                       TAG_DONE
  873.                     );
  874.  
  875.    for (i = 1; i < MAXNODE; i++)          // 0 = title string for ListView
  876.        NodeStrs[ i * NODELENGTH ] = '\0'; // Kill old ListView strings.
  877.  
  878.    // Make the list:
  879.    (void) MakeTaskList();
  880.  
  881.    GT_SetGadgetAttrs( TaskGadgets[ TaskLV ], Wnd, NULL, 
  882.                       GTLV_Selected, 0, TAG_DONE
  883.                     );
  884.    
  885.    GT_RefreshWindow( Wnd, NULL );
  886.  
  887.    return( (int) TRUE );
  888. }
  889.  
  890. PRIVATE struct Window *FindTaskWindow( struct Task *task )
  891. {
  892.    struct Window *win, *taskwindow = NULL;
  893.    struct Screen *scr;
  894.    ULONG          lock = 0L;
  895.  
  896.    lock = LockIBase( NULL );
  897.  
  898.    scr = IntuitionBase->FirstScreen;
  899.    while ((scr != NULL) && (taskwindow == NULL))
  900.       {
  901.       win = scr->FirstWindow;
  902.      
  903.       while (win != NULL)
  904.          {
  905.          if ((win->UserPort != NULL) 
  906.               && (win->UserPort->mp_SigTask == task))
  907.             {
  908.             taskwindow = win;
  909.             break;
  910.             }
  911.  
  912.          win = win->NextWindow;
  913.          }
  914.  
  915.       scr = scr->NextScreen;
  916.       }
  917.  
  918.    UnlockIBase( lock );
  919.  
  920.    return( taskwindow );
  921. }
  922.  
  923. PUBLIC BOOL IsMsgPort_Empty( struct MsgPort *p )
  924. {
  925.    BOOL rval = FALSE;
  926.  
  927.    if (p == NULL)
  928.       return( TRUE );
  929.  
  930.    if (p->mp_MsgList.lh_TailPred == (struct Node *) &(p->mp_MsgList))
  931.       rval = TRUE;
  932.    
  933.    return( rval );
  934. }
  935.      
  936. PUBLIC void RemovePortSafely( struct MsgPort *port )
  937. {
  938.    struct Node *MsgNode;
  939.  
  940.    if (port == NULL)
  941.       return;
  942.  
  943.    Forbid();
  944.  
  945.      if (IsMsgPort_Empty( port ) == FALSE)
  946.         {
  947.         MsgNode = port->mp_MsgList.lh_Head;
  948.  
  949.         while ((MsgNode = MsgNode->ln_Succ) != NULL)
  950.            Remove( (struct Node *) MsgNode );
  951.         }
  952.  
  953.      if (port->mp_Node.ln_Name != NULL)
  954.         RemPort( port );
  955.  
  956.      port->mp_SigTask         = (struct Task *) -1;
  957.      port->mp_MsgList.lh_Head = (struct Node *) -1;
  958.  
  959.      DeletePort( port );
  960.  
  961.   Permit();
  962.  
  963.   return;
  964. }
  965.  
  966. PRIVATE void CloseTheWindow( struct Window *wind )
  967. {
  968.    if (CheckWindow( wind ) == TRUE)
  969.       {
  970.       if ((wind->ReqCount != 0) && wind->FirstRequest)
  971.          {
  972.          while (wind->ReqCount != 0)
  973.             EndRequest( wind->FirstRequest, wind );
  974.          }
  975.  
  976.       if (wind->DMRequest != NULL)
  977.          ClearDMRequest( wind );
  978.  
  979.       if (wind->Pointer != NULL)
  980.          ClearPointer( wind );
  981.  
  982.       if (wind->MenuStrip != NULL)
  983.          ClearMenuStrip( wind );
  984.  
  985.       CloseWindow( wind );
  986.       }
  987.  
  988.    return;
  989. }
  990.  
  991. PRIVATE struct Window *TaskWindow( struct Task *task )
  992. {
  993.    return( FindTaskWindow( task ) );
  994.  
  995. /* struct Window *rval = NULL;
  996.  
  997.    Forbid();
  998.  
  999.       if (task->tc_Node.ln_Type == NT_PROCESS)
  1000.          {
  1001.          struct Process *process = (struct Process *) task;
  1002.  
  1003.          if ((struct Window *) process->pr_WindowPtr != NULL)
  1004.             rval = ((struct Window *) process->pr_WindowPtr);
  1005.          }
  1006.  
  1007.    Permit();
  1008.  
  1009.    return( rval );
  1010. */
  1011. }
  1012.  
  1013. PRIVATE struct MsgPort *TaskPort( struct Task *task )
  1014. {
  1015.    struct MsgPort *rval = NULL;
  1016.    
  1017.    Forbid();
  1018.  
  1019.       if (task->tc_Node.ln_Type == NT_PROCESS)
  1020.          {
  1021.          struct Process *process = (struct Process *) task;
  1022.  
  1023.          rval = &(process->pr_MsgPort);
  1024.          }
  1025.    
  1026.    Permit();
  1027.  
  1028.    return( rval );
  1029. }
  1030.  
  1031. PRIVATE void KillTask( struct Task *task )
  1032. {
  1033.    struct Window  *taskwin = NULL;
  1034.    struct MsgPort *port    = NULL;
  1035.  
  1036.    Forbid();
  1037.      Disable();
  1038.        Remove( (struct Node *) task );
  1039.      Enable();
  1040.  
  1041.      if ((taskwin = TaskWindow( task )) != NULL)
  1042.         {
  1043.         struct Screen *taskscr = NULL;
  1044.         ULONG          lock    = LockIBase( NULL );
  1045.  
  1046.         if ((taskwin->WScreen != NULL) 
  1047.            && ((taskwin->WScreen->Flags & CUSTOMSCREEN) == CUSTOMSCREEN))
  1048.            taskscr = taskwin->WScreen;
  1049.  
  1050.         while (taskwin != NULL)
  1051.            {
  1052.            CloseTheWindow( taskwin );
  1053.            taskwin = TaskWindow( task );
  1054.            }
  1055.  
  1056.         if (taskscr != NULL)
  1057.            CloseScreen( taskscr );
  1058.   
  1059.         UnlockIBase (lock);
  1060.         }
  1061.  
  1062.      while (port = TaskPort( task ) != NULL)
  1063.         RemovePortSafely( port );
  1064.  
  1065.      Disable();
  1066.        RemTask( task );
  1067.      Enable();
  1068.  
  1069.    Permit();
  1070.  
  1071.    return;
  1072. }
  1073.  
  1074. PRIVATE int RemoveClicked( int dummy )
  1075. {
  1076.    char  m[80], *msg = &m[0];
  1077.    BOOL  answer = FALSE;
  1078.    
  1079.    sprintf( msg, "Are you SURE you want to Remove %08x?", TaskAddress );
  1080.  
  1081.    answer = SanityCheck( msg );
  1082.  
  1083.    if (answer == TRUE)
  1084.       KillTask( (struct Task *) TaskAddress );  // Send the remove command:
  1085.  
  1086.    return( (int) TRUE );
  1087. }
  1088.  
  1089. PRIVATE int PriorityClicked( int dummy )
  1090. {
  1091.    char m[80], *msg = &m[0];
  1092.    BOOL answer = FALSE;
  1093.    
  1094.    sprintf( msg, "Are you SURE you want to Re-Prioritize %08x?", 
  1095.             TaskAddress 
  1096.           );
  1097.  
  1098.    answer = SanityCheck( msg );
  1099.  
  1100.    if (answer == TRUE)
  1101.       {
  1102.       struct Task *taddr = (struct Task *) TaskAddress;
  1103.       struct Node *tnode = &(taddr->tc_Node);
  1104.  
  1105.       ULONG OldPri = tnode->ln_Pri;
  1106.  
  1107.       // re-prioritize the task:
  1108.  
  1109.       if (ChangePriorityHandler( tnode->ln_Name,
  1110.                                  tnode->ln_Type,
  1111.                                  OldPri 
  1112.                                ) < 0)
  1113.          {
  1114.          // Error condition:
  1115.          }
  1116.       }
  1117.  
  1118.    return( (int) TRUE );
  1119. }
  1120.  
  1121. PRIVATE int FreezeClicked( int dummy )
  1122. {
  1123.    char  m[80], *msg = &m[0];
  1124.    BOOL  answer = FALSE;
  1125.    
  1126.    sprintf( msg, "Are you SURE you want to Freeze %08x?", TaskAddress );
  1127.  
  1128.    answer = SanityCheck( msg );
  1129.  
  1130.    if (answer == TRUE)
  1131.       {
  1132.       // Send the freeze command:
  1133.       UserInfo( "Not implemented yet!", "USER Information:" );
  1134.       }
  1135.  
  1136.    return( (int) TRUE );
  1137. }
  1138.  
  1139. PRIVATE int MoreClicked( int dummy )
  1140. {
  1141.    if (((struct Task *) TaskAddress)->tc_Node.ln_Type == NT_PROCESS)
  1142.       (void) HandleWindowInfo( (void *) TaskAddress, 3 );
  1143.    else
  1144.       (void) HandleWindowInfo( (void *) TaskAddress, 2 );
  1145.  
  1146.    DisplayTitle( Wnd, WTitle );   
  1147.  
  1148.    return( (int) TRUE );
  1149. }
  1150.  
  1151. PRIVATE int SignalClicked( int dummy )
  1152. {
  1153. //   ULONG usersignals = 0L;
  1154.    char  m[80], *msg = &m[0];
  1155.    BOOL  answer = FALSE;
  1156.    
  1157.    sprintf( msg, "Are you SURE you want to Signal %08x?", TaskAddress );
  1158.  
  1159.    answer = SanityCheck( msg );
  1160.  
  1161.    if (answer == TRUE)
  1162.       {
  1163.       // get the signal number from the user via requester:
  1164. //      usersignals = GetUserSignals( (struct Task *) TaskAddress );
  1165. //      Signal( TaskAddress, usersignals );
  1166.       UserInfo( "Not implemented yet!", "USER Information:" );
  1167.       }
  1168.  
  1169.    return( (int) TRUE );
  1170. }
  1171.  
  1172. PRIVATE int BreakClicked( int dummy )
  1173. {
  1174.    char m[80], *msg = &m[0];
  1175.    BOOL answer = FALSE;
  1176.    
  1177.    sprintf( msg, "Are you SURE you want to Break %08x?", TaskAddress );
  1178.  
  1179.    answer = SanityCheck( msg );
  1180.  
  1181.    if (answer == TRUE)
  1182.       {
  1183.       // Send the Break command:
  1184.       UserInfo( "Not implemented yet!", "USER Information:" );
  1185.       }
  1186.  
  1187.    return( (int) TRUE );
  1188. }
  1189.  
  1190. // CLose stuff: CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC
  1191.  
  1192. PRIVATE void CloseTaskWindow( void )
  1193. {
  1194.    if (Wnd)
  1195.       {
  1196.       CloseWindow( Wnd );
  1197.       Wnd = NULL;
  1198.       }
  1199.  
  1200.    if (GList)
  1201.       {
  1202.       FreeGadgets( GList );
  1203.       GList = NULL;
  1204.       }
  1205.  
  1206.    if (TFont)
  1207.       {
  1208.       CloseFont( TFont );
  1209.       TFont = NULL;
  1210.       }
  1211.  
  1212.    return;
  1213. }
  1214.  
  1215. PRIVATE int TaskCloseWindow( void )
  1216. {
  1217.    CloseTaskWindow();
  1218.    return( (int) FALSE );
  1219. }
  1220.  
  1221. PRIVATE int CancelClicked( int dummy )
  1222. {
  1223.    return( TaskCloseWindow() );
  1224. }
  1225.  
  1226. // CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC
  1227.  
  1228. PRIVATE int OpenTaskWindow( void )
  1229. {
  1230.    struct NewGadget  ng = { 0, };
  1231.    struct Gadget    *g  = NULL;
  1232.    UWORD             lc = 0, tc = 0;
  1233.    UWORD             wleft = WLeft, wtop = WTop, ww, wh;
  1234.  
  1235.    ComputeFont( Scr, Font, &CFont, WWidth, WHeight );
  1236.  
  1237.    ww = ComputeX( CFont.FontX, WWidth );
  1238.    wh = ComputeY( CFont.FontY, WHeight );
  1239.  
  1240.    if ((wleft + ww + CFont.OffX + Scr->WBorRight) > Scr->Width)
  1241.       wleft = Scr->Width - ww;
  1242.  
  1243.    if ((wtop + wh + CFont.OffY + Scr->WBorBottom) > Scr->Height)
  1244.       wtop = Scr->Height - wh;
  1245.  
  1246.    if ((TFont = OpenDiskFont( Font )) == NULL)
  1247.       return( -5 );
  1248.  
  1249.    if ((g = CreateContext( &GList )) == NULL)
  1250.       return( -1 );
  1251.  
  1252.    for (lc = 0, tc = 0; lc < T_CNT; lc++)
  1253.       {
  1254.       CopyMem( (char *) &TaskNGad[ lc ], (char *) &ng, 
  1255.                (long) sizeof( struct NewGadget )
  1256.              );
  1257.  
  1258.       ng.ng_VisualInfo = VisualInfo;
  1259.       ng.ng_TextAttr   = Font;
  1260.       ng.ng_LeftEdge   = CFont.OffX + ComputeX( CFont.FontX,
  1261.                                                 ng.ng_LeftEdge
  1262.                                               );
  1263.  
  1264.       ng.ng_TopEdge    = CFont.OffY + ComputeY( CFont.FontY,
  1265.                                                 ng.ng_TopEdge
  1266.                                               );
  1267.  
  1268.       ng.ng_Width      = ComputeX( CFont.FontX, ng.ng_Width );
  1269.       ng.ng_Height     = ComputeY( CFont.FontY, ng.ng_Height );
  1270.  
  1271.       TaskGadgets[ lc] = 
  1272.                     g  = CreateGadgetA( (ULONG) TaskGTypes[ lc ], 
  1273.                            g, 
  1274.                            &ng, 
  1275.                            (struct TagItem *) &TaskGTags[ tc ] );
  1276.  
  1277.       while (TaskGTags[tc])
  1278.          tc += 2;
  1279.  
  1280.       tc++;
  1281.  
  1282.       if (g == NULL)
  1283.          return( -2 );
  1284.       }
  1285.  
  1286.    if ( !(Wnd = OpenWindowTags( NULL,
  1287.                          
  1288.                   WA_Left,        wleft,
  1289.                   WA_Top,         wtop,
  1290.                   WA_Width,       ww + CFont.OffX + Scr->WBorRight,
  1291.                   WA_Height,      wh + CFont.OffY + Scr->WBorBottom,
  1292.  
  1293.                   WA_IDCMP,       LISTVIEWIDCMP | BUTTONIDCMP 
  1294.                     | IDCMP_CLOSEWINDOW | IDCMP_REFRESHWINDOW,
  1295.  
  1296.                   WA_Flags,       WFLG_DRAGBAR | WFLG_DEPTHGADGET 
  1297.                     | WFLG_CLOSEGADGET | WFLG_SMART_REFRESH 
  1298.                     | WFLG_ACTIVATE | WFLG_RMBTRAP,
  1299.                   
  1300.                   WA_Gadgets,     GList,
  1301.                   WA_Title,       WTitle,
  1302.                   TAG_DONE ))
  1303.       )
  1304.       return( -4 );
  1305.  
  1306.    GT_RefreshWindow( Wnd, NULL );
  1307.  
  1308.    return( 0 );
  1309. }
  1310.  
  1311. PRIVATE int HandleTaskIDCMP( void )
  1312. {
  1313.    struct IntuiMessage *m;
  1314.    int                 (*func)( int );
  1315.    BOOL                running = TRUE;
  1316.  
  1317.    while (running == TRUE)
  1318.       {
  1319.       if ((m = GT_GetIMsg( Wnd->UserPort )) == NULL)
  1320.          {
  1321.          (void) Wait( 1L << Wnd->UserPort->mp_SigBit );
  1322.          continue;
  1323.          }
  1324.  
  1325.       CopyMem( (char *) m, (char *) &IMsg, 
  1326.                (long) sizeof( struct IntuiMessage )
  1327.              );
  1328.  
  1329.       GT_ReplyIMsg( m );
  1330.  
  1331.       switch (IMsg.Class)
  1332.          {
  1333.          case IDCMP_REFRESHWINDOW:
  1334.             GT_BeginRefresh( Wnd );
  1335.             GT_EndRefresh( Wnd, TRUE );
  1336.             break;
  1337.  
  1338.          case IDCMP_CLOSEWINDOW:
  1339.             running = TaskCloseWindow();
  1340.             break;
  1341.  
  1342.          case IDCMP_GADGETUP:
  1343.          case IDCMP_GADGETDOWN:
  1344.             func    = (void *) ((struct Gadget *) IMsg.IAddress)->UserData;
  1345.             running = func( IMsg.Code );
  1346.             break;
  1347.          }
  1348.       }
  1349.  
  1350.    return( running );
  1351. }
  1352.  
  1353. PUBLIC int HandleTaskListView( void )
  1354. {
  1355.    int i = 0;
  1356.    
  1357.    if (SetupSystemList( &OpenTaskWindow ) < 0)
  1358.       {
  1359.       fprintf( stderr, "Couldn't open a System ListViewer!\n" );
  1360.       return( -1 );
  1361.       }
  1362.    
  1363.    SetNotifyWindow( Wnd );
  1364.  
  1365.    lvm.lvm_NodeStrs   = &NodeStrs[0];
  1366.    lvm.lvm_Nodes      = &TskLVNodes[0];
  1367.    lvm.lvm_NumItems   = MAXNODE;
  1368.    lvm.lvm_NodeLength = NODELENGTH;
  1369.  
  1370.    SetupList( &TskLVList, &lvm );   
  1371.  
  1372.    strcpy( TskLVNodes[0].ln_Name, ttl );
  1373.  
  1374.    // Make the list:
  1375.    (void) MakeTaskList();   
  1376.  
  1377.    ModifyListView( TaskGadgets[ TaskLV ], Wnd, 
  1378.                    (struct List *) &TskLVList, NULL
  1379.                  );
  1380.  
  1381.    GT_RefreshWindow( Wnd, NULL );
  1382.  
  1383.    (void) HandleTaskIDCMP();
  1384.    
  1385.    ShutdownSystemList();
  1386.    return( 0 );
  1387. }
  1388.  
  1389. PUBLIC int main( void )
  1390. {
  1391.    return( HandleTaskListView() );
  1392. }
  1393.  
  1394. /* ------------------- END of SysTasks.c file! --------------------- */
  1395.